package it.nexus.core.dao;

import it.nexus.core.tools.ReflectionUtils;
import org.hibernate.*;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.hibernate.metadata.ClassMetadata;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

/**
 * Created by IntelliJ IDEA.
 * User: dcriori
 * Date: 2010-5-5
 * Time: 15:54:26
 * 使用了springside的simplehibernatedao类
 */
@SuppressWarnings("unchecked")
public class HibernateDao<T, PK extends Serializable> {

  protected Logger logger = LoggerFactory.getLogger(getClass());

  protected SessionFactory sessionFactory;

  protected Class<T> entityClass;

  /**
   * 用于Dao层子类使用的构造函数.
   * 通过子类的泛型定义取得对象类型Class.
   * eg.
   * public class UserDao extends SimpleHibernateDao<User, Long>
   */
  public HibernateDao() {
    this.entityClass = ReflectionUtils.getSuperClassGenricType(getClass());
  }

  /**
   * 用于用于省略Dao层, 在Service层直接使用通用SimpleHibernateDao的构造函数.
   * 在构造函数中定义对象类型Class.
   * eg.
   * HibernateDao<User, Long> userDao = new HibernateDao<User, Long>(sessionFactory, User.class);
   */
  public HibernateDao(final SessionFactory sessionFactory, final Class<T> entityClass) {
    this.sessionFactory = sessionFactory;
    this.entityClass = entityClass;
  }

  /**
   * 取得sessionFactory.
   */
  public SessionFactory getSessionFactory() {
    return sessionFactory;
  }

  /**
   * 采用@Autowired按类型注入SessionFactory, 当有多个SesionFactory的时候Override本函数.
   */
  @Autowired
  public void setSessionFactory(final SessionFactory sessionFactory) {
    this.sessionFactory = sessionFactory;
  }

  /**
   * 取得当前Session.
   */
  public Session getSession() {
    return sessionFactory.getCurrentSession();
  }

  /**
   * 保存新增或修改的对象.
   */
  public void save(final T entity) {
    Assert.notNull(entity, "entity不能为空");
    getSession().saveOrUpdate(entity);
    logger.debug("save entity: {}", entity);
  }

  /**
   * 删除对象.
   *
   * @param entity 对象必须是session中的对象或含id属性的transient对象.
   */
  public void delete(final T entity) {
    Assert.notNull(entity, "entity不能为空");
    getSession().delete(entity);
    logger.debug("delete entity: {}", entity);
  }

  /**
   * 按id删除对象.
   */
  public void delete(final PK id) {
    Assert.notNull(id, "id不能为空");
    delete(get(id));
    logger.debug("delete entity {},id is {}", entityClass.getSimpleName(), id);
  }

  /**
   * 按id获取对象.
   */
  public T get(final PK id) {
    Assert.notNull(id, "id不能为空");
    return (T) getSession().load(entityClass, id);
  }

  /**
   * 获取全部对象.
   */
  public List<T> getAll() {
    return find();
  }

  /**
   * 获取全部对象,支持排序.
   */
  public List<T> getAll(String orderBy, boolean isAsc) {
    Criteria c = createCriteria();
    if (isAsc) {
      c.addOrder(Order.asc(orderBy));
    } else {
      c.addOrder(Order.desc(orderBy));
    }
    return c.list();
  }

  /**
   * 按属性查找对象列表,匹配方式为相等.
   */
  public List<T> findBy(final String propertyName, final Object value) {
    Assert.hasText(propertyName, "propertyName不能为空");
    Criterion criterion = Restrictions.eq(propertyName, value);
    return find(criterion);
  }

  /**
   * 按属性查找唯一对象,匹配方式为相等.
   */
  public T findUniqueBy(final String propertyName, final Object value) {
    Assert.hasText(propertyName, "propertyName不能为空");
    Criterion criterion = Restrictions.eq(propertyName, value);
    return (T) createCriteria(criterion).uniqueResult();
  }

  /**
   * 按id列表获取对象.
   */
  public List<T> findByIds(List<PK> ids) {
    return find(Restrictions.in(getIdName(), ids));
  }

  /**
   * 按HQL查询对象列表.
   *
   * @param values 数量可变的参数,按顺序绑定.
   */
  public <X> List<X> find(final String hql, final Object... values) {
    return createQuery(hql, values).list();
  }

  /**
   * 按HQL查询对象列表.
   *
   * @param values 命名参数,按名称绑定.
   */
  public <X> List<X> find(final String hql, final Map<String, ?> values) {
    return createQuery(hql, values).list();
  }

  /**
   * 按HQL查询唯一对象.
   *
   * @param values 数量可变的参数,按顺序绑定.
   */
  public <X> X findUnique(final String hql, final Object... values) {
    return (X) createQuery(hql, values).uniqueResult();
  }

  /**
   * 按HQL查询唯一对象.
   *
   * @param values 命名参数,按名称绑定.
   */
  public <X> X findUnique(final String hql, final Map<String, ?> values) {
    return (X) createQuery(hql, values).uniqueResult();
  }

  /**
   * 执行HQL进行批量修改/删除操作.
   */
  public int batchExecute(final String hql, final Object... values) {
    return createQuery(hql, values).executeUpdate();
  }

  /**
   * 执行HQL进行批量修改/删除操作.
   *
   * @return 更新记录数.
   */
  public int batchExecute(final String hql, final Map<String, ?> values) {
    return createQuery(hql, values).executeUpdate();
  }

  /**
   * 根据查询HQL与参数列表创建Query对象.
   * <p/>
   * 本类封装的find()函数全部默认返回对象类型为T,当不为T时使用本函数.
   *
   * @param values 数量可变的参数,按顺序绑定.
   */
  public Query createQuery(final String queryString, final Object... values) {
    Assert.hasText(queryString, "queryString不能为空");
    Query query = getSession().createQuery(queryString);
    if (values != null) {
      for (int i = 0; i < values.length; i++) {
        query.setParameter(i, values[i]);
      }
    }
    return query;
  }

  /**
   * 根据查询HQL与参数列表创建Query对象.
   *
   * @param values 命名参数,按名称绑定.
   */
  public Query createQuery(final String queryString, final Map<String, ?> values) {
    Assert.hasText(queryString, "queryString不能为空");
    Query query = getSession().createQuery(queryString);
    if (values != null) {
      query.setProperties(values);
    }
    return query;
  }

  /**
   * 按Criteria查询对象列表.
   *
   * @param criterions 数量可变的Criterion.
   */
  public List<T> find(final Criterion... criterions) {
    return createCriteria(criterions).list();
  }

  /**
   * 按Criteria查询唯一对象.
   *
   * @param criterions 数量可变的Criterion.
   */
  public T findUnique(final Criterion... criterions) {
    return (T) createCriteria(criterions).uniqueResult();
  }

  /**
   * 根据Criterion条件创建Criteria.
   * <p/>
   * 本类封装的find()函数全部默认返回对象类型为T,当不为T时使用本函数.
   *
   * @param criterions 数量可变的Criterion.
   */
  public Criteria createCriteria(final Criterion... criterions) {
    Criteria criteria = getSession().createCriteria(entityClass);
    for (Criterion c : criterions) {
      criteria.add(c);
    }
    return criteria;
  }

  /**
   * 初始化对象.
   * 使用load()方法得到的仅是对象Proxy, 在传到View层前需要进行初始化.
   * 只初始化entity的直接属性,但不会初始化延迟加载的关联集合和属性.
   * 如需初始化关联属性,可实现新的函数,执行:
   * Hibernate.initialize(user.getRoles())，初始化User的直接属性和关联集合.
   * Hibernate.initialize(user.getDescription())，初始化User的直接属性和延迟加载的Description属性.
   */
  public void initEntity(T entity) {
    Hibernate.initialize(entity);
  }

  /**
   * @see #initEntity(Object)
   */
  public void initEntity(List<T> entityList) {
    for (T entity : entityList) {
      Hibernate.initialize(entity);
    }
  }

  /**
   * Flush当前Session.
   */
  public void flush() {
    getSession().flush();
  }

  /**
   * 为Query添加distinct transformer.
   */
  public Query distinct(Query query) {
    query.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
    return query;
  }

  /**
   * 为Criteria添加distinct transformer.
   */
  public Criteria distinct(Criteria criteria) {
    criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
    return criteria;
  }

  /**
   * 取得对象的主键名.
   */
  public String getIdName() {
    ClassMetadata meta = getSessionFactory().getClassMetadata(entityClass);
    return meta.getIdentifierPropertyName();
	}
}
